/*学习不定参宏函数的使用*/

#define LOG(fmt, ...) printf("[%s:%d] " fmt, __FILE__, __LINE__, ##__VA_ARGS__);

// int main()
// {
//    LOG("%s-%d\n", "ch和nx", 666);
//     return 0;
// }



/*学习不定参函数的使用*/
#define _GNU_SOURCE
#include<stdarg.h>
#include<stdlib.h>
#include<stdio.h>
void printNum(int count, ...)
{
    va_list ap;   //创建一个ap指针，相当于创建了一个数组，里面包含了不定参数集合
    va_start(ap, count);    //将ap定位到count下一个参数的起始位置。

    for (int i = 0; i < count; i++)
    {
        char* num = va_arg(ap, char*);     //获取ap里面的数据， 这里是拿整形数据.
        LOG("param[%d]:%p\n", i, num);
    }
    va_end(ap);   //将ap指针置为空
}

void myprintf(const char* fmt, ...)
{
    va_list ap;   //创建ap指针
    va_start(ap, fmt);   //将指针定位到fmt的后一个位置

    char* res;
    int ret = vasprintf(&res, fmt, ap);
    if (ret != -1)
    {
        printf(res);
        free(res);
    }

    va_end(ap);
}

// int main()
// {
//     printNum(5, 1, 2, 3, "a", 3);
//     myprintf("nx和ch\n");
//     return 0;
// }

/*C++风格的不定参函数使用*/

#include<iostream>
using namespace std;
#include<memory>
void xprintf()
{
    cout << "yes" << endl;
}
template<typename T, typename ...Args>
void xprintf(const T& v, Args&& ...args)
{
    cout << v;
    if ((sizeof ...(args)) > 0)  //如果没有了， 那么就else了， 如果有的话
    {
        xprintf(forward<Args>(args)...); //对args完美转发， 
    }
    else
    {
        cout << endl;
    }
}

// int main()
// {
//     xprintf("nx");
//     xprintf("nx", " ch");
//     xprintf("nx", " ch", "666");
//     return 0;
// }

/*设计模式六大原则*/


/*单例模式*/

//饿汉，以空间换取时间
class Singleton
{
private:
    Singleton():_data(99){}
    ~Singleton(){}
    Singleton(const Singleton&) = delete;
    const Singleton& operator=(const Singleton&) = delete;

    static Singleton _eton;
private:
    int _data;
public:
    static Singleton& GetInstance()
    {
        return _eton;
    }
    int GetData(){return _data;}
};

Singleton Singleton::_eton;

// int main()
// {
//     cout << Singleton::GetInstance().GetData();
//     return 0;
// }

//懒汉模式， 延迟加载的思想， 一个对象再进行实例化

class Singleton2
{
private:
    Singleton2():_data(99){}
    ~Singleton2(){}
    Singleton2(const Singleton2&) = delete;
    const Singleton2& operator=(const Singleton2&) = delete;

    int _data;

public:
    static Singleton2& GetInstance()
    {
        static Singleton2 _eton;
        return _eton;
    }
    int GetData()
    {
        return _data;
    }
};



/*工厂模式*/

//创建型模式， 提供创建的最佳方式。把一个对象创建封装起来。实现创建-使用分离。
class Fruit
{
public:
    virtual void name() = 0;
};

class Apple : public Fruit
{
public:
    void name() override
    {
        cout << "我是一个苹果！" << endl;
    };
};

class Banana : public Fruit
{
public:
    void name() override
    {
        cout << "我是一个香蕉！" << endl;
    }
};

// class FruitFactory
// {
// public:
//     static shared_ptr<Fruit> create(const string& name)
//     {
//         if (name == "苹果")
//         {
//             return make_shared<Apple>();
//         }
//         else
//         {
//             return make_shared<Banana>();
//         }
//     }
// };


// int main()
// {
//     shared_ptr<Fruit> fruit = FruitFactory::create("苹果");
//     fruit->name();
//     fruit = FruitFactory::create("香蕉");
//     fruit->name();

//     return 0;
// }

class FruitFactory
{
public:
    virtual shared_ptr<Fruit> create() = 0;
};

class AppleFactory : public FruitFactory
{
public:
    shared_ptr<Fruit> create() override
    {
        return make_shared<Apple>();   //这里就是多态
    }    
};

class BananaFactory : public FruitFactory
{
public:
    shared_ptr<Fruit> create() override
    {
        return make_shared<Banana>();
    }
};


 